home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / HDF / dfkit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  11.2 KB  |  403 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.10 $"
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfkit.c,v 3.10 90/07/02 09:37:52 clow beta $
  27. $Log:    dfkit.c,v $
  28.  * Revision 3.10  90/07/02  09:37:52  clow
  29.  * enclosed DFconvert macro and function with an #ifdef on FUNC_CONV
  30.  * so that the selection between these is a compilation option
  31.  * 
  32.  * Revision 3.9  90/06/21  10:40:53  clow
  33.  * Changes UNICOS conversion functions for non-UNICOS env to be similar
  34.  * to the UNICOS fortran functions, and
  35.  * "#if 0" out the DFconvert function, use macro in dfconvert.h
  36.  * 
  37.  * Revision 3.8  90/06/07  17:39:28  clow
  38.  * bug fix in conversion routines
  39.  * 
  40. */
  41. /*
  42.  * Changes:
  43.  *    DFconvert() calls FORTRAN conversion routines if compiled with UNICOS 
  44.  *    DFconvert() takes an array rather than a single number
  45.  *    Register parameters have been declared
  46.  *    Pointers are now used rather than array indexing
  47.  */
  48. /* Modified DFconvert so that it takes an array rather than a single number */
  49. /* Now call FORTRAN conversion routines */
  50. #include <ctype.h>
  51. #include "df.h"
  52.  
  53. union fpx
  54. {
  55.      float f;
  56.      long  l;
  57. };
  58.  
  59. union float_uint_uchar {
  60.     float32 f;
  61.     int32 i;
  62.     unsigned char c[4];
  63. };
  64.  
  65. char *DFIstrncpy(dest, source, len)
  66. register char *source, *dest;
  67. int len;
  68. {
  69.  
  70.     for(; (--len > 0) && (*dest++ = *source++););
  71.     if (!len) *dest = '\0';
  72.     return(dest);
  73. }
  74.  
  75. #ifdef FUNC_CONV
  76. /* function convert, otherwise, this function is done in macro (dfconvert.h) */
  77. int DFconvert(source, dest, ntype, sourcetype, desttype, size)
  78. char *source, *dest;
  79. int ntype;
  80. register int sourcetype, desttype;
  81. int size;
  82. {
  83.     register char t;      /* Temporary, used in byte-swapping */
  84.     register int i;
  85.     int status;
  86.  
  87.     if (ntype==DFNT_FLOAT) {
  88.  
  89.     if (((sourcetype==DFNTF_IEEE) && ( desttype==DFNTF_PC)) ||
  90.         ((sourcetype==DFNTF_PC) && (desttype==DFNTF_IEEE))) {
  91.             for (i=0; i<size*4; i+=4)
  92.               {
  93.             dest[i  ] = source[i+3];
  94.             dest[i+1] = source[i+2];
  95.             dest[i+2] = source[i+1];
  96.             dest[i+3] = source[i  ];
  97.               }
  98.         return(0);
  99.     }
  100.  
  101.     /* if reversed IEEE, reverse before conversion */
  102.     if (sourcetype==DFNTF_PC) {
  103.       sourcetype=DFNTF_IEEE;
  104.           for (i=0; i<size*4; i+=4)
  105.             {
  106.           t           = source[i];
  107.           source[i  ] = source[i+3];
  108.               source[i+3] = t;
  109.           t           = source[i+1];
  110.           source[i+1] = source[i+2];
  111.               source[i+2] = t;
  112.             }
  113.     }
  114.  
  115.         if ((sourcetype==DFNTF_IEEE) && (desttype==DFNTF_CRAY)) {
  116. #ifdef UNICOS
  117.             SCUP32(source, dest, &size, &status);
  118. #else
  119.             if (DFCVieeeF2unicosF(source,(union fpx*) dest, size)<0)
  120.                return(-1);
  121. #endif
  122.         } else if ((sourcetype==DFNTF_CRAY) &&
  123.            ((desttype==DFNTF_IEEE) || (desttype==DFNTF_PC))) {
  124. #ifdef UNICOS
  125.             CSPK32(source, dest, &size, &status);
  126. #else
  127.             if (DFCVunicosF2ieeeF((union fpx*)source, dest, size)<0) 
  128.                return(-1);
  129. #endif
  130.     }
  131.  
  132.         if ((sourcetype==DFNTF_IEEE) && (desttype==DFNTF_VAX)) {
  133.             if (DFCVieeeF2vaxF((union float_uint_uchar *) source,
  134.                    (union float_uint_uchar *) dest, size)<0)
  135.         return(-1);
  136.         } else if ((sourcetype==DFNTF_VAX) &&
  137.            ((desttype==DFNTF_IEEE) || (desttype==DFNTF_PC))) {
  138.             if (DFCVvaxF2ieeeF((union float_uint_uchar*) source,
  139.                    (union float_uint_uchar*) dest, size)<0)
  140.         return(-1);
  141.         }
  142.  
  143.     /* if reversed IEEE, reverse result */
  144.     if (desttype==DFNTF_PC) {
  145.           for (i=0; i<size*4; i+=4)
  146.             {
  147.           t         = dest[i+3];
  148.           dest[i+3] = dest[i];
  149.           dest[i  ] = t;
  150.           t         = dest[i+2];
  151.           dest[i+2] = dest[i+1];
  152.           dest[i+1] = t;
  153.             }
  154.     }
  155.     return(0);
  156.     }
  157.         /* default */
  158.     DFerror = DFE_BADCONV;
  159.     return(-1);
  160. }
  161. #endif /* FUNC_CONV */
  162.  
  163. char *DFIgetspace(qty)
  164. unsigned qty;
  165. {
  166.     char *p;
  167.  
  168.     p = malloc(qty);
  169.     if (p==NULL) {
  170.         DFerror = DFE_NOSPACE;
  171.         return(NULL);
  172.     }
  173.     return(p);
  174. }
  175.  
  176. char *DFIfreespace(ptr)
  177. char *ptr;
  178. {
  179.     if (ptr!=NULL) free(ptr);
  180.     return(NULL);
  181. }
  182.  
  183.  
  184. #ifdef UNICOS
  185.  
  186. #define MINEXP    0x3f81000000000000  /* min valid Cray masked exponent */
  187. #define MAXEXP    0x407e000000000000  /* max valid Cray masked exponent */
  188.  
  189. #define C_FMASK   0x00007fffff000000  /* Cray fraction mask (1st 23 bits)*/
  190. #define C_EMASK   0x7fff000000000000  /* Cray exponent mask */
  191. #define C_SMASK   0x8000000000000000  /* Cray sign mask */
  192. #define C_IMPLICIT 0x0000800000000000 /* Cray implicit bit */
  193.  
  194. #define I_FMASK   0x007fffff          /* IEEE fraction mask */
  195. #define I_EMASK   0x7f800000          /* IEEE exponent mask */
  196. #define I_SMASK   0x80000000          /* IEEE sign mask     */
  197.  
  198. #define IEEE_BIAS 0177
  199. #define CRAY_BIAS 040000
  200.  
  201. #endif /*UNICOS*/
  202.  
  203. /* On UNICOS, this function is defined as a fortran function */
  204. #ifndef UNICOS
  205.     /*  convert from Cray2 floating point format to IEEE format */
  206. /* shut lint up */
  207. /* ARGSUSED */
  208. CSPK32(cray_fp, ieee_fp, size, status)
  209. char *cray_fp;
  210. char *ieee_fp;
  211. int *size;
  212. int *status;
  213. {
  214.     DFerror = DFE_BADCONV;
  215.     *status = -1;
  216. }
  217. #endif /*!UNICOS*/
  218.  
  219. #if 0
  220. /* Old cray conversion routine */
  221.     register int i;
  222.     register long C2I_diff;
  223.     long tmp;
  224.     C2I_diff = (IEEE_BIAS - CRAY_BIAS - 1) << 48;
  225.     for (i=0; i<size; i++, cray_fp++, ieee_fp+=4)
  226.       {
  227.         if (cray_fp->l == 0)
  228.           tmp = 0;
  229.         else {
  230.           tmp = (C_EMASK & cray_fp->l);
  231.           if (tmp < MINEXP || tmp > MAXEXP) {
  232.               DFerror = DFE_BADFP;
  233.               return(-1);
  234.           }
  235.  
  236.           tmp = ((tmp + C2I_diff) << 7)
  237.             | ( (cray_fp->l & C_FMASK) << 8 )
  238.             | ( (cray_fp->l & C_SMASK));
  239.         }
  240.         DFmovmem((char *)&tmp, ieee_fp, 4);
  241.       }
  242.     return(0);
  243. }
  244. #endif /* 0 */
  245.  
  246. /* On UNICOS, this function is defined as a fortran function */
  247. #ifndef UNICOS
  248. /* Conversion from IEEE floating point format to Cray format */
  249. /* shut lint up */
  250. /* ARGSUSED */
  251. SCUP32(ieee_fp, cray_fp, size, status)
  252. char *cray_fp;
  253. char *ieee_fp;
  254. int *size;
  255. int *status;
  256. {
  257.     DFerror = DFE_BADCONV;
  258.     *status = -1;
  259. }
  260. #endif /*!UNICOS*/
  261.  
  262. #if 0
  263. register union fpx *cray_fp;
  264. register char *ieee_fp;
  265. int size;
  266. {
  267.     long tmp;
  268.     register int i;
  269.     register long I2C_diff;
  270.  
  271.     I2C_diff = (CRAY_BIAS - IEEE_BIAS + 1) << 23;
  272.     for (i=0; i<size; i++, ieee_fp+=4, cray_fp++)
  273.       {
  274.         tmp = 0;
  275.         DFmovmem(ieee_fp, ((char *) &tmp) + 4, 4); 
  276.  
  277.         if ( (cray_fp->l = tmp & I_EMASK) == 0) {
  278.           cray_fp->l = 0;
  279.           continue;
  280.         }
  281.  
  282.         cray_fp->l += I2C_diff;
  283.         cray_fp->l = (cray_fp->l<< 25)
  284.            | ( (tmp & I_FMASK) << 24)
  285.            | ( (tmp & I_SMASK) << 32)
  286.        | C_IMPLICIT;
  287.       }
  288.     return (0);
  289.  
  290. }
  291. #endif /* 0 */
  292.  
  293. DFIc2fstr(str, len)
  294. char* str;
  295. int len;
  296. {
  297.     int i;
  298.  
  299.     for(i=0; (str[i]); i++);
  300.     for(; i<len; i++) str[i] = ' ';
  301. }
  302.  
  303. char *DFIf2cstring(fdesc, len)
  304.     _fcd fdesc;
  305.     int len;
  306. {
  307.     char *cstr, *str;
  308.     int i;
  309.  
  310.     str = _fcdtocp(fdesc);
  311.     for(i=len-1;i>=0 && (!isascii(str[i]) || !isgraph(str[i])); i--)
  312.     /*EMPTY*/;
  313.     cstr = DFIgetspace(i+2);
  314.     cstr[i+1] = '\0';
  315.     for (; i>=0; i--) cstr[i] = str[i];
  316.     return cstr;
  317. }
  318.  
  319. int DFCVvaxF2ieeeF(in, out, size)
  320. union float_uint_uchar in[], out[];
  321. int size;
  322. {
  323.     register unsigned char exp;
  324.     int i;
  325.  
  326.     for (i=0; i<size; i++)
  327.       {
  328.         exp = (in[i].c[1] << 1) | (in[i].c[0] >> 7);  /* extract exponent */
  329.         if (!exp && !in[i].c[1]) out[i].i = 0;        /* zero value */
  330.         else if (exp>2) {                               /* normal value */
  331.             out[i].c[0] = in[i].c[1] - 1; /* subtracts 2 from exponent */
  332.                 /* copy mantissa, LSB of exponent */
  333.             out[i].c[1] = in[i].c[0];
  334.             out[i].c[2] = in[i].c[3];
  335.             out[i].c[3] = in[i].c[2];
  336.         }
  337.         else if (exp) {                          /* denormalized number */
  338.             register int shft;
  339.  
  340.             out[i].c[0] = in[i].c[1] & 0x80;   /* keep sign, zero exponent */
  341.             shft = 3 - exp;
  342.             /* shift original mant by 1 or 2 to get denormalized mant */
  343.             /* prefix mantissa with '1'b or '01'b as appropriate */
  344.             out[i].c[1] = ((in[i].c[0] & 0x7f) >> shft) | (0x10 << exp);
  345.             out[i].c[2] = (in[i].c[0] << (8-shft)) | (in[i].c[3] >> shft);
  346.             out[i].c[3] = (in[i].c[3] << (8-shft)) | (in[i].c[2] >> shft);
  347.         }
  348.         else {                                  /* sign=1 -> infinity or NaN */
  349.             out[i].c[0] = 0xff;                /* set exp to 255 */
  350.                 /* copy mantissa */
  351.             out[i].c[1] = in[i].c[0] | 0x80;  /* LSB of exp = 1 */
  352.             out[i].c[2] = in[i].c[3];
  353.             out[i].c[3] = in[i].c[2];
  354.         }
  355.       }
  356.     return(0);
  357. }
  358.  
  359.  
  360. int DFCVieeeF2vaxF(in, out, size)
  361. union float_uint_uchar in[], out[];
  362. int size;
  363. {
  364.     register unsigned char exp;
  365.     int i;
  366.  
  367.     for (i=0; i<size; i++)
  368.       {
  369.          exp = (in[i].c[0] << 1) | (in[i].c[1] >> 7); /* extract exponent */
  370.          if (exp) {                                  /* non-zero exponent */
  371.             /* copy mantissa, last bit of exponent */
  372.            out[i].c[0] = in[i].c[1];
  373.            out[i].c[2] = in[i].c[3];
  374.            out[i].c[3] = in[i].c[2];
  375.            if (exp<254)                        /* normal value */
  376.              out[i].c[1] = in[i].c[0] + 1;   /* actually adds two to exp */
  377.            else {                              /* infinity or NaN */
  378.              if (exp==254)                     /* unrepresentable - OFL */
  379.                out[i].i = 0;                  /* set mant=0 for overflow */
  380.             out[i].c[0] &= 0x7f;              /* set last bit of exp to 0 */
  381.             out[i].c[1] = 0x80;               /* sign=1 exp=0 -> OFL or NaN */
  382.           }
  383.         }
  384.         else if (in[i].c[1] & 0x60) {               /* denormalized value */
  385.           register int shft;
  386.     
  387.           shft = (in[i].c[1] & 0x40) ? 1 : 2;  /* shift needed to normalize */
  388.             /* shift mantissa */
  389.             /* note last bit of exp set to 1 implicitly */
  390.           out[i].c[0] = (in[i].c[1] << shft) & (in[i].c[2] >> (8-shft));
  391.           out[i].c[3] = (in[i].c[2] << shft) & (in[i].c[3] >> (8-shft));
  392.           out[i].c[2] = in[i].c[3] << shft;
  393.           out[i].c[1] = (in[i].c[0] & 0x80);          /* sign */
  394.           if (shft==1) {                          /* set exp to 2 */
  395.             out[i].c[1] |= 0x01;
  396.             out[i].c[0] &= 0x7f;                  /* set LSB of exp to 0 */
  397.           }
  398.         }
  399.         else out[i].i = 0;                            /* zero */
  400.       }
  401.     return(0);
  402. }
  403.